home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / utl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  62.5 KB  |  2,023 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 42
  2. /*______________________________________________________________________
  3.  
  4.      utl.c - Utilities.
  5.     
  6.      Copyright © 1988, 1989, 1990 Northwestern University.    Permission is granted
  7.      to use this code in your own projects, provided you give credit to both
  8.      John Norstad and Northwestern University in your about box or document.
  9.     
  10.      This module exports miscellaneous reusable utility routines.
  11. _____________________________________________________________________*/
  12.  
  13.  
  14. #pragma load EUDORA_LOAD
  15.  
  16. #pragma segment utl
  17.  
  18. /*______________________________________________________________________
  19.  
  20.      Global Variables.
  21. _____________________________________________________________________*/
  22.  
  23.  
  24. static SysEnvRec         TheWorld;            /* system environment record */
  25. static Boolean             GotSysEnviron = false; 
  26.                                                                         /* true if sys environ has been
  27.                                                                              gotten */
  28.     
  29.                 
  30. static CursHandle      *CursArray;        /* ptr to array of cursor handles */
  31. static short                 NumCurs;             /* number of cursors to rotate */
  32. static short                 TickInterval;    /* number of ticks between rotations */
  33. static short                 CurCurs;             /* index of current cursor */
  34. static short                 LastTick;            /* tick count at loast rotation */
  35.  
  36. static ModalFilterProcPtr  Filter;    /* dialog filter proc */
  37. static short                 CancelItem;        /* item number of cancel button */
  38.  
  39. /*______________________________________________________________________
  40.  
  41.      GetSysEnvirons - Get System Environment.
  42.     
  43.      Exit:        global variable TheWorld = system environment record.
  44.                         global variable GotSysEnviron = true.
  45. _____________________________________________________________________*/
  46.  
  47.  
  48. static void GetSysEnvirons (void)
  49.  
  50. {
  51.      if (!GotSysEnviron) {
  52.             (void) SysEnvirons(curSysEnvVers, &TheWorld);
  53.             GotSysEnviron = true;
  54.      };
  55. }
  56.  
  57. /*______________________________________________________________________
  58.  
  59.      utl_AppendDITL - Append DITL to End of Dialog.
  60.     
  61.      Entry:     theDialog = pointer to dialog.
  62.                         theDITLID = rsrc id of DITL.
  63.                             
  64.      Exit:        function result = item number of first appended item.
  65.     
  66.      The dialog window is expanded to accomodate the new items, and the
  67.      new items are offset to appear at the bottom of the dialog.
  68.     
  69.      This routine is particularly useful for appending items to the
  70.      standard Page Setup and Print Job dialogs.  (See TN 95).  It was
  71.      written by Lew Rollins of Apple's Human-Systems Interface Group,
  72.      in MPW Pascal.  I translated it to MPW C.
  73.     
  74.      The only significant difference between this routine and Rollin's
  75.      version is that this version does not release the DITL resource.
  76. _____________________________________________________________________*/
  77.  
  78.  
  79. short utl_AppendDITL (DialogPtr theDialog, short theDITLID)
  80.  
  81. {
  82.      typedef struct DITLItem {
  83.             Handle                 itmHndl;                  /* handle or proc ptr */
  84.             Rect                     itmRect;                  /* display rect */
  85.             char                     itmType;                  /* item type */
  86.             unsigned char  itmData;                  /* item data length byte */
  87.      } DITLItem;
  88.     
  89.      typedef struct itemList {
  90.             short                  dlgMaxIndex;          /* num items - 1 */
  91.             DITLItem             DITLItems[1];         /* array of DITL items */
  92.      } itemList;
  93.     
  94.      short                    offset;              /* item offset */
  95.      Rect                     maxRect;             /* max dialog rect size so far */
  96.      Handle                 hDITL;                 /* handle to DITL */
  97.      DITLItem             *pItem;              /* pointer to item being appended */
  98.      itemList             **hItems;          /* handle to DLOG's item list */
  99.      short                    sizeDITL;          /* size of DLOG's item list */
  100.      short                    firstItem;         /* item num of first appended item */
  101.      short                    newItems;          /* number of new items */
  102.      short                    dataSize;          /* size of data for current item */
  103.      short                    i;                         /* loop index */
  104.     
  105.      /* Initialize. */
  106.     
  107.      maxRect = theDialog->portRect;
  108.      offset = maxRect.bottom;
  109.      maxRect.bottom -= 5;
  110.      maxRect.right -= 5;
  111.      hItems = (itemList**)(((DialogPeek)theDialog)->items);
  112.      sizeDITL = GetHandleSize((Handle)hItems);
  113.      firstItem = (**hItems).dlgMaxIndex + 2;
  114.      hDITL = GetResource('DITL', theDITLID);
  115.      HLock(hDITL);
  116.      newItems = **(short**)hDITL + 1;
  117.      PtrAndHand(*hDITL+2, (Handle)hItems,
  118.             GetHandleSize(hDITL)-2);
  119.      (**hItems).dlgMaxIndex += newItems;
  120.      HUnlock(hDITL);
  121.      HLock((Handle)hItems);
  122.      (char*)pItem = (char*)(*hItems) + sizeDITL;
  123.     
  124.      /* Main loop.    Add each item to dialog item list. */
  125.     
  126.      for (i = 1; i <= newItems; i++) {
  127.             OffsetRect(&pItem->itmRect, 0, offset);
  128.             UnionRect(&pItem->itmRect, &maxRect, &maxRect);
  129.             switch (pItem->itmType & 0x7f) {
  130.                  case ctrlItem+btnCtrl:
  131.                  case ctrlItem+chkCtrl:
  132.                  case ctrlItem+radCtrl:
  133.                         pItem->itmHndl = (Handle)NewControl(theDialog,
  134.                              &pItem->itmRect, &pItem->itmData, true, 0, 0, 1, 
  135.                              pItem->itmType & 0x03, 0);
  136.                         break;
  137.                  case ctrlItem+resCtrl:
  138.                         pItem->itmHndl = (Handle)GetNewControl(
  139.                              *(short*)(&pItem->itmData+1),
  140.                              theDialog);
  141.                         (**((ControlHandle)(pItem->itmHndl))).contrlRect =
  142.                              pItem->itmRect;
  143.                         break;
  144.                  case statText:
  145.                  case editText:
  146.                         PtrToHand(&pItem->itmData+1, (Handle *)&(pItem->itmHndl), 
  147.                              pItem->itmData);
  148.                         break;
  149.                  case iconItem:
  150.                         pItem->itmHndl = GetIcon(*(short*)(&pItem->itmData+1));
  151.                         break;
  152.                  default:
  153.                         pItem->itmHndl = nil;
  154.             };
  155.             dataSize = (pItem->itmData + 1) & 0xfffe;
  156.             (char*)pItem += dataSize + sizeof(DITLItem);
  157.      };
  158.     
  159.      /* Finish up. */
  160.     
  161.      HUnlock((Handle)hItems);
  162.      maxRect.bottom += 5;
  163.      maxRect.right += 5;
  164.      SizeWindow(theDialog, maxRect.right, maxRect.bottom, true);
  165.      return firstItem;
  166. }
  167.  
  168. /*______________________________________________________________________
  169.  
  170.      utl_CenterDlogRect - Center a dialog rectangle.
  171.     
  172.      Entry:     rect = rectangle.
  173.                         centerMain = true to center on main (menu bar) screen.
  174.                         centerMain = false to center on the screen containing
  175.                              the maximum intersection with the frontmost window.
  176.     
  177.      Exit:        rect = rectangle offset so that it is centered on
  178.                              the specified screen, with twice as much space below
  179.                              the rect as above.
  180.                             
  181.      See HIN 6.
  182. _____________________________________________________________________*/
  183.  
  184.  
  185. void utl_CenterDlogRect (Rect *rect, Boolean centerMain)
  186.  
  187. {
  188.      Rect         screenRect;             /* screen rectangle */
  189.      short        mBHeight;                 /* menu bar height */
  190.      GDHandle gd;                             /* gdevice */
  191.      Rect         windRect;                 /* window rectangle */
  192.      Boolean    hasMB;                        /* true if screen contains menu bar */
  193.  
  194.      mBHeight = utl_GetMBarHeight();
  195.      if (centerMain) {
  196.             screenRect = qd.screenBits.bounds;
  197.      } else {
  198.             utl_GetWindGD(FrontWindow(), &gd, &screenRect, &windRect, &hasMB);
  199.             if (!hasMB) mBHeight = 0;
  200.      };
  201.      OffsetRect(rect,
  202.             (screenRect.right + screenRect.left - rect->right - rect->left) >> 1,
  203.             (screenRect.bottom + ((screenRect.top + mBHeight - rect->top)<<1) - 
  204.                  rect->bottom + 7) / 3);
  205. }
  206.  
  207. /*______________________________________________________________________
  208.  
  209.      utl_CenterRect - Center a rectangle on the main screen.
  210.     
  211.      Entry:     rect = rectangle.
  212.     
  213.      Exit:        rect = rectangle offset so that it is centered on
  214.                              the main screen.
  215. _____________________________________________________________________*/
  216.  
  217.  
  218. void utl_CenterRect (Rect *rect)
  219.  
  220. {
  221.      Rect         screenRect;             /* main screen rectangle */
  222.      short        mBHeight;                 /* menu bar height */
  223.  
  224.      mBHeight = utl_GetMBarHeight();
  225.      screenRect = qd.screenBits.bounds;
  226.      OffsetRect(rect,
  227.             (screenRect.right + screenRect.left - rect->right - rect->left) >> 1,
  228.             (screenRect.bottom - screenRect.top + mBHeight -
  229.                  rect->bottom - rect->top) >> 1);
  230. }
  231.  
  232. /*______________________________________________________________________
  233.  
  234.      utl_CheckPack - Check to see if a package exists.
  235.     
  236.      Entry:     packNum = package number.
  237.                         preload = true to preload package.
  238.                             
  239.      Exit:        function result = true if package exists.
  240. _____________________________________________________________________*/
  241.  
  242.  
  243. Boolean utl_CheckPack (short packNum, Boolean preload)
  244.  
  245. {
  246.      short             trapNum;             /* trap number */
  247.      Handle          h;                         /* handle to PACK resource */
  248.     
  249.      /* Check to make sure the trap exists, by comparing its trap address to
  250.             the trap address of the unimplemented trap. */
  251.     
  252.      trapNum = packNum + 0x1e7;
  253.      if (NGetTrapAddress(trapNum & 0x3ff, ToolTrap) ==
  254.             NGetTrapAddress(_Unimplemented & 0x3ff, ToolTrap)) return false;
  255.             
  256.      /* Check to make sure the package exists on the System file or in
  257.             ROM.    If it's not in ROM make it nonpurgeable, if requested. */
  258.     
  259.      if (preload) {
  260.             if (utl_Rom64()) {
  261.                  h = GetResource('PACK', packNum);
  262.                  if (!h) return false;
  263.                  HNoPurge(h);
  264.             } else {
  265.                  *(unsigned short*)RomMapInsert = 0xFF00;
  266.                  h = GetResource('PACK', packNum);
  267.                  if (!h) return false;
  268.                  if ((*(unsigned long*)h & 0x00FFFFFF) <
  269.                         *(unsigned long*)ROMBase) {
  270.                         h = GetResource('PACK', packNum);
  271.                         HNoPurge(h);
  272.                  };
  273.             };
  274.             return true;
  275.      } else {
  276.             SetResLoad(false);
  277.             if (!utl_Rom64()) *(unsigned short*)RomMapInsert = 0xFF00;
  278.             h = GetResource('PACK', packNum);
  279.             SetResLoad(true);
  280.             if (h) return true; else return false;
  281.      };
  282. }
  283.  
  284. /*______________________________________________________________________
  285.  
  286.      utl_CopyPString - Copy Pascal String.
  287.     
  288.      Entry:     dest = destination string.
  289.                         source = source string.
  290. _____________________________________________________________________*/
  291.  
  292.  
  293. void utl_CopyPString (Str255 dest, Str255 source)
  294.  
  295. {
  296.      memcpy(dest, source, *source+1);
  297. }
  298.  
  299. /*______________________________________________________________________
  300.  
  301.      utl_CouldDrag - Determine if a window could be dragged to a location.
  302.     
  303.      Entry:     windRect = window rectangle, in global coords.
  304.                         offset = pixel offset used in DragRect calls.
  305.     
  306.      Exit:        function result = true if the window could have been
  307.                              dragged to the specified position.
  308.                             
  309.      This routine is used when restoring windows to saved positions.    According
  310.      to HIN 6, we must check to see if the window "could have been dragged to
  311.      the saved position."
  312.     
  313.      The "offset" parameter is usually 4.  When initializing the boundary rectangle
  314.      for DragWindow calls, normally the boundary rectangle of the desktop gray
  315.      region is inset by 4 pixels.  If some value other than 4 is used, it should
  316.      be passed to CouldDrag as the "offset" parameter.
  317.     
  318.      The algorithm used is the following:  The routine computes the four squares
  319.      at the corners of the title bar.  "true" is returned if and only if at least one 
  320.      of these four squares is completely contained within the desktop gray region.
  321.     
  322.      Three pixels are added to the offset to err on the side of requiring a larger
  323.      portion of the drag bar to be visible. 
  324. _____________________________________________________________________*/
  325.  
  326.  
  327. Boolean utl_CouldDrag (Rect *windRect, short offset)
  328.  
  329. {
  330.      RgnHandle                 rgn;              /* scratch region handle */
  331.      Boolean                     could;          /* function result */
  332.      short                         corner;         /* which corner */
  333.      Rect                          r;                  /* corner rectangle */
  334.  
  335.      rgn = NewRgn();
  336.      could = false;
  337.      offset += 3;
  338.      for (corner = 1; corner <= 4; corner++) {
  339.             switch (corner) {
  340.                  case 1:
  341.                         r.top = windRect->top - titleBarHeight;
  342.                         r.left = windRect->left;
  343.                         break;
  344.                  case 2:
  345.                         r.top = windRect->top - offset;
  346.                         r.left = windRect->left;
  347.                         break;
  348.                  case 3:
  349.                         r.top = windRect->top - titleBarHeight;
  350.                         r.left = windRect->right - offset;
  351.                         break;
  352.                  case 4:
  353.                         r.top = windRect->top - offset;
  354.                         r.left = windRect->right - offset;
  355.                         break;
  356.             };
  357.             r.bottom = r.top + offset;
  358.             r.right = r.left + offset;
  359.             RectRgn(rgn, &r);
  360.             DiffRgn(rgn, *(RgnHandle*)GrayRgn, rgn);
  361.             if (EmptyRgn(rgn)) {
  362.                  could = true;
  363.                  break;
  364.             };
  365.      };
  366.      DisposeRgn(rgn);
  367.      return could;
  368. }
  369.  
  370. /*______________________________________________________________________
  371.  
  372.      utl_DILoad - Load Disk Initialization Package.
  373.     
  374.      Exit:        Disk initialization package loaded.
  375.                         
  376.      This routine is identical to the DILoad routine (see IM II-396),
  377.      except that it closes any resource files opened by the routine.    This is
  378.      necessary to undo a bug in the DaynaFile software.  DaynaFile patches
  379.      DILoad.    The patch opens a resource file without closing it.  The
  380.      effect on Disinfectant if we don't do anything about this is that 
  381.      the DaynaFile icon is displayed in Disinfectant's main window instead of
  382.      Disinfectant's icon.  
  383. _____________________________________________________________________*/
  384.  
  385.  
  386. void utl_DILoad (void)
  387.  
  388. {
  389.      short             curResFile;             /* ref num of current resource file
  390.                                                                         before calling DILoad */
  391.      short             topResFile;             /* ref num of top resource file
  392.                                                                         after calling DILoad */
  393.     
  394.      curResFile = CurResFile();
  395.      DILoad();
  396.      while ((topResFile = CurResFile()) != curResFile) CloseResFile(topResFile);
  397. }
  398.  
  399. /*______________________________________________________________________
  400.  
  401.      utl_DoDiskInsert - Handle a disk inserted event.
  402.     
  403.      Entry:     message = message field from disk insertion event record
  404.                              = 16/MountVol return code, 16/drive number.
  405.     
  406.      Exit:        vRefNum = vol ref num of inserted volume.
  407.                         function result = error code.
  408.     
  409.      If MountVol returned an error code, the disk initialization package
  410.      is called to initialize the disk.
  411. _____________________________________________________________________*/
  412.  
  413.  
  414. OSErr utl_DoDiskInsert (long message, short *vRefNum)
  415.  
  416. {
  417.      OSErr                    rCode;                        /* result code */
  418.      short                    driveNum;                 /* drive number */
  419.      HParamBlockRec pBlock;                     /* vol info param block */
  420.      Handle                 dlgHandle;                /* handle to disk init dialog */
  421.      Rect                     dlgRect;                    /* disk init dialog rectangle */
  422.      Point                    where;                        /* location of disk init dialog */
  423.      short                    curVol;                     /* index in VCB queue */
  424.     
  425.      /* Get result code and drive number from event message. */
  426.     
  427.      rCode = (message >> 16) & 0xffff;
  428.      driveNum = message & 0xffff;
  429.     
  430.      /* If the result code indicates an error, call DIBadMount to initialize
  431.             the disk. */
  432.             
  433.      if (rCode) {
  434.             
  435.             /* Center the disk initialization package dialog. */
  436.             
  437.             DILoad();
  438.             dlgHandle = GetResource('DLOG', -6047);
  439.             dlgRect = **(Rect**)dlgHandle;
  440.             utl_CenterDlogRect(&dlgRect, false);
  441.             SetPt(&where, dlgRect.left, dlgRect.top);
  442.             
  443.             /* Call DIBadMount. */
  444.             
  445.             if (rCode = DIBadMount(where, message)) return rCode;
  446.             
  447.      };
  448.     
  449.      /* Search mounted volumes to find inserted one. */
  450.     
  451.      pBlock.volumeParam.ioNamePtr = nil;
  452.      curVol = 0;
  453.      while (true) {
  454.             pBlock.volumeParam.ioVolIndex = ++curVol;
  455.             pBlock.volumeParam.ioVRefNum = 0;
  456.             if (rCode = PBHGetVInfo(&pBlock, false)) return rCode;
  457.             if (pBlock.volumeParam.ioVDrvInfo == driveNum) break;
  458.      };
  459.      *vRefNum = pBlock.volumeParam.ioVRefNum;
  460.      return noErr;
  461. } 
  462.  
  463. /*______________________________________________________________________
  464.  
  465.      utl_DrawGrowIcon - Draw Grow Icon.
  466.     
  467.      Entry:                 theWindow = pointer to window.
  468.     
  469.      This routine is identical to the Window Manager routine
  470.      DrawGrowIcon, except that it does not draw the lines enclosing the
  471.      scroll bars.
  472. _____________________________________________________________________*/
  473.  
  474.  
  475. void utl_DrawGrowIcon (WindowPtr theWindow) 
  476.  
  477. {
  478.      RgnHandle                 clipRgn;             /* saved clip region */
  479.      Rect                          clipRect;            /* clip rectangle */
  480.     
  481.      clipRgn = NewRgn();
  482.      GetClip(clipRgn);
  483.      clipRect = theWindow->portRect;
  484.      clipRect.left = clipRect.right - 15;
  485.      clipRect.top = clipRect.bottom - 15;
  486.      ClipRect(&clipRect);
  487.      DrawGrowIcon(theWindow);
  488.      SetClip(clipRgn);
  489.      DisposeRgn(clipRgn);
  490. }
  491.  
  492. /*______________________________________________________________________
  493.  
  494.      utl_Ejectable - Test for ejectable volume.
  495.     
  496.      Entry:     vRefNum = volume reference number.
  497.     
  498.      Exit:        function result = true if volume is on an ejectable drive.
  499. _____________________________________________________________________*/
  500.  
  501.  
  502. Boolean utl_Ejectable (short vRefNum)
  503.     
  504. {
  505.      HParamBlockRec pBlock;                     /* vol info param block */
  506.      short                    driveNum;                 /* driver number of cur vol */
  507.      DrvQEl                 *curDrive;                /* ptr to current drive queue element */
  508.      OSErr                    rCode;                        /* result code */
  509.      unsigned char    flagByte;                 /* drive queue element flag byte */
  510.     
  511.      /* Get driveNum = drive number of drive containing volume. */
  512.     
  513.      pBlock.volumeParam.ioNamePtr = nil;
  514.      pBlock.volumeParam.ioVolIndex = 0;
  515.      pBlock.volumeParam.ioVRefNum = vRefNum;;
  516.      if (rCode = PBHGetVInfo(&pBlock, false)) return false;
  517.      driveNum = pBlock.volumeParam.ioVDrvInfo;
  518.     
  519.      /* Walk the drive queue until we find driveNum.    The second byte in
  520.             the four flag bytes preceding the drive queue element is 8 or $48 
  521.             if the drive is nonejectable. */
  522.     
  523.      curDrive = (DrvQEl*)(GetDrvQHdr())->qHead;
  524.      while (true) {
  525.             if (curDrive->dQDrive == driveNum) {
  526.                  flagByte = *((Ptr)curDrive - 3);
  527.                  return (flagByte != 8 && flagByte != 0x48);
  528.             };
  529.             curDrive = (DrvQEl*)curDrive->qLink;
  530.             if (!curDrive) return false;
  531.      };
  532. }
  533.  
  534. /*______________________________________________________________________
  535.  
  536.      utl_FixStdFile - Fix Standard File Pacakge.
  537.     
  538.      This routine should be called before calling the Standard File 
  539.      package if there's any chance that SFSaveDisk might specify
  540.      a volume that has been umounted.  Standard File gets confused if this
  541.      happens and presents an alert telling the user that a "system error"
  542.      has occurred.
  543.     
  544.      This routine checks to make sure that SFSaveDisk specifies a volume
  545.      that is still mounted.  If not, it sets it to the first mounted
  546.      volume, and it sets CurDirStore to the root directory on that volume.
  547. _____________________________________________________________________*/
  548.                             
  549.                             
  550. void utl_FixStdFile (void)
  551.  
  552. {
  553.      ParamBlockRec    vBlock;              /* vol info param block */
  554.                                                                         
  555.      vBlock.volumeParam.ioNamePtr = nil;
  556.      vBlock.volumeParam.ioVRefNum = -*(short*)SFSaveDisk;
  557.      vBlock.volumeParam.ioVolIndex = 0;
  558.      if (PBGetVInfo(&vBlock, false)) {
  559.             vBlock.volumeParam.ioVolIndex = 1;
  560.             (void) PBGetVInfo(&vBlock, false);
  561.             *(short*)SFSaveDisk = -vBlock.volumeParam.ioVRefNum;
  562.             if (*(short*)FSFCBLen > 0) *(long*)CurDirStore = fsRtDirID;
  563.      };
  564. }
  565.  
  566. /*______________________________________________________________________
  567.  
  568.      utl_FlashButton - Flash Dialog Button.
  569.     
  570.      Entry:     theDialog = pointer to dialog.
  571.                         itemNo = item number of button to flash.
  572.                         
  573.      The push button is inverted for 8 ticks.  See HIN #10.
  574. _____________________________________________________________________*/
  575.  
  576.  
  577. void utl_FlashButton (DialogPtr theDialog, short itemNo)
  578.  
  579. {
  580.      short             itemType;                 /* item type */
  581.      Handle          item;                         /* item handle */
  582.      Rect              box;                          /* item rectangle */
  583.      short             roundFactor;          /* rounded corner factor for InvertRoundRect */
  584.      long              tickEnd;                  /* tick count to end flash */
  585.     
  586.      GetDItem(theDialog, itemNo, &itemType, &item, &box);
  587.      SetPort(theDialog);
  588.      roundFactor = (box.bottom - box.top)>>1;
  589.      InvertRoundRect(&box, roundFactor, roundFactor);
  590.      tickEnd = TickCount() + 8;
  591.      while (TickCount() < tickEnd);
  592.      InvertRoundRect(&box, roundFactor, roundFactor);
  593. }
  594.  
  595. /*______________________________________________________________________
  596.  
  597.      utl_FrameItem
  598.     
  599.      Entry:     theWindow = pointer to dialog window.
  600.                         itemNo = dialog item number.
  601.     
  602.      Exit:        dialog item rectangle framed.
  603.                         
  604.      This function is for use as a Dialog Manager user item procedure.
  605.      It is particularly useful for drawing rules (straight lines).    Simply
  606.      define the user item rectangle with bottom=top+1 or right=left+1.
  607. _____________________________________________________________________*/
  608.  
  609.  
  610. pascal void utl_FrameItem (WindowPtr theWindow, short itemNo)
  611.  
  612. {
  613.      short             itemType;                 /* item type */
  614.      Handle          item;                         /* item handle */
  615.      Rect              box;                          /* item rectangle */
  616.  
  617.      GetDItem(theWindow, itemNo, &itemType, &item, &box);
  618.      FrameRect(&box);
  619. }
  620.  
  621. /*______________________________________________________________________
  622.  
  623.      utl_GetApplVol - Get the volume reference number of the application volume.
  624.     
  625.      Exit:        function result = volume reference number of the volume 
  626.                              containing the current application.
  627. _____________________________________________________________________*/
  628.  
  629.  
  630. short utl_GetApplVol (void)
  631.  
  632. {
  633.      short             vRefNum;                  /* vol ref num */
  634.  
  635.      GetVRefNum(*(short*)(CurMap), &vRefNum);
  636.      return vRefNum;
  637. }
  638.  
  639. /*______________________________________________________________________
  640.  
  641.      utl_GetBlessedWDRefNum - Get the working directory reference number of
  642.             the Blessed Folder.
  643.     
  644.     
  645.      Exit:        function result = wdRefNum of blessed folder
  646. _____________________________________________________________________*/
  647.  
  648.  
  649. short utl_GetBlessedWDRefNum (void)
  650.  
  651. {
  652.      if (!GotSysEnviron) GetSysEnvirons();
  653.      return TheWorld.sysVRefNum;
  654. }
  655.  
  656. /*______________________________________________________________________
  657.  
  658.      utl_GetFontNumber - Get Font Number.
  659.     
  660.      Entry:     fontName = font name.
  661.     
  662.      Exit:        function result = true if font exists.
  663.                         fontNum = font number.
  664.                         
  665.      Copied from TN 191.
  666. _____________________________________________________________________*/
  667.  
  668.  
  669. Boolean utl_GetFontNumber (Str255 fontName, short *fontNum)
  670.  
  671. {
  672.      Str255          systemFontName;
  673.     
  674.      GetFNum(fontName, fontNum);
  675.      if (*fontNum) {
  676.             return true;
  677.      } else {
  678.             GetFontName(0, systemFontName);
  679.             return EqualString(fontName, systemFontName, false, false);
  680.      };
  681. }
  682.  
  683. /*______________________________________________________________________
  684.  
  685.      utl_GetLongSleep - Get Long Sleep Time.
  686.     
  687.      Exit:             function result = long sleep time.
  688.     
  689.      Returns the largest positive long integer (0x7fffffff) if the
  690.      system version is > 0x04ff, else returns 50.  See TN 177.
  691. _____________________________________________________________________*/
  692.  
  693.  
  694. long utl_GetLongSleep (void)
  695.  
  696. {
  697.      if (!GotSysEnviron) GetSysEnvirons();
  698.      return (TheWorld.systemVersion > 0x04ff) ? 0x7fffffff : 50;
  699. }
  700.  
  701. /*______________________________________________________________________
  702.  
  703.      utl_GetMBarHeight - Get Menu Bar Height
  704.     
  705.      Exit:        function result = menu bar height.
  706.     
  707.      See TN 117.
  708. _____________________________________________________________________*/
  709.  
  710.  
  711. short utl_GetMBarHeight (void)
  712.  
  713. {
  714.      static short          mBHeight = 0;
  715.     
  716.      if (!mBHeight) {
  717.             mBHeight = utl_Rom64() ? 20 : *(short*)MBarHeight;
  718.      };
  719.      return mBHeight;
  720. }
  721.  
  722. /*______________________________________________________________________
  723.  
  724.      utl_GetNewControl - Get New Control.
  725.     
  726.      Entry:     controlID = resource id of CNTL resource.
  727.                         theWindow = pointer to window record.
  728.                         
  729.      Exit:        function result = handle to new control record.
  730.                         
  731.      This routine is identical to the Control Manager routine GetNewControl,
  732.      except it does not release or make purgeable the CNTL resource.
  733. _____________________________________________________________________*/
  734.  
  735.  
  736. ControlHandle utl_GetNewControl (short controlID, 
  737.      WindowPtr theWindow)
  738.     
  739. {
  740.      Rect              boundsRect;             /* boundary rectangle */
  741.      short             value;                      /* initial control value */
  742.      Boolean         visible;                  /* true if visible */
  743.      short             max;                          /* max control value */
  744.      short             min;                          /* min control value */
  745.      short             procID;                     /* window proc id */
  746.      long              refCon;                     /* refCon field for window record */
  747.      Str255          title;                      /* window title */
  748.      Handle          theRez;                     /* handle to CNTL resource */
  749.     
  750.      theRez = GetResource('CNTL', controlID);
  751.      boundsRect = *(Rect*)(*theRez);
  752.      value = *(short*)(*theRez+8);
  753.      visible = *(Boolean*)(*theRez+10);
  754.      max = *(short*)(*theRez+12);
  755.      min = *(short*)(*theRez+14);
  756.      procID = *(short*)(*theRez+16);
  757.      refCon = *(long*)(*theRez+18);
  758.      utl_CopyPString(title, *theRez+22);
  759.      return NewControl(theWindow, &boundsRect, title, visible, value,
  760.             min, max, procID, refCon);
  761. }
  762.  
  763. /*______________________________________________________________________
  764.  
  765.      utl_GetNewDialog - Get New Dialog.
  766.     
  767.      Entry:     dialogID = resource id of DLOG resource.
  768.                         dStorage = pointer to dialog record.
  769.                         behind = window to insert in back of.
  770.                         
  771.      Exit:        function result = pointer to new dialog record.
  772.                         
  773.      This routine is identical to the Dialog Manager routine GetNewDialog,
  774.      except it does not release or make purgeable the DLOG resource.
  775. _____________________________________________________________________*/
  776.  
  777.  
  778. DialogPtr utl_GetNewDialog (short dialogID, Ptr dStorage, 
  779.      WindowPtr behind)
  780.     
  781. {
  782.      Rect              boundsRect;             /* boundary rectangle */
  783.      short             procID;                     /* window proc id */
  784.      Boolean         visible;                  /* true if visible */
  785.      Boolean         goAwayFlag;             /* true if window has go away box */
  786.      long              refCon;                     /* refCon field for window record */
  787.      Str255          title;                      /* window title */
  788.      Handle          theRez;                     /* handle to DLOG resource */
  789.      short             itemID;                     /* rsrc id of item list */
  790.      Handle          items;                      /* handle to item list */
  791.     
  792.      theRez = GetResource('DLOG', dialogID);
  793.      boundsRect = *(Rect*)(*theRez);
  794.      procID = *(short*)(*theRez+8);
  795.      visible = *(Boolean*)(*theRez+10);
  796.      goAwayFlag = *(Boolean*)(*theRez+12);
  797.      refCon = *(long*)(*theRez+14);
  798.      itemID = *(short*)(*theRez+18);
  799.      utl_CopyPString(title, *theRez+20);
  800.      items = GetResource('DITL', itemID);
  801.      return NewDialog(dStorage, &boundsRect, title, visible, procID, behind,
  802.             goAwayFlag, refCon, items);
  803. }
  804.  
  805. /*______________________________________________________________________
  806.  
  807.      utl_GetNewWindow - Get New Window.
  808.     
  809.      Entry:     windowID = resource id of WIND resource.
  810.                         wStorage = pointer to window record.
  811.                         behind = window to insert in back of.
  812.                         
  813.      Exit:        function result = pointer to new window record.
  814.                         
  815.      This routine is identical to the Window Manager routine GetNewWindow,
  816.      except it does not release or make purgeable the WIND resource.
  817. _____________________________________________________________________*/
  818.  
  819.  
  820. WindowPtr utl_GetNewWindow (short windowID, Ptr wStorage, 
  821.      WindowPtr behind)
  822.     
  823. {
  824.      Rect              boundsRect;             /* boundary rectangle */
  825.      short             procID;                     /* window proc id */
  826.      Boolean         visible;                  /* true if visible */
  827.      Boolean         goAwayFlag;             /* true if window has go away box */
  828.      long              refCon;                     /* refCon field for window record */
  829.      Str255          title;                      /* window title */
  830.      Handle          theRez;                     /* handle to WIND resource */
  831.     
  832.      theRez = GetResource('WIND', windowID);
  833.      boundsRect = *(Rect*)(*theRez);
  834.      procID = *(short*)(*theRez+8);
  835.      visible = *(Boolean*)(*theRez+10);
  836.      goAwayFlag = *(Boolean*)(*theRez+12);
  837.      refCon = *(long*)(*theRez+14);
  838.      utl_CopyPString(title, *theRez+18);
  839.      return NewWindow(wStorage, &boundsRect, title, visible, procID, behind,
  840.             goAwayFlag, refCon);
  841. }
  842.  
  843. /*______________________________________________________________________
  844.  
  845.      utl_GetSysVol - Get the volume reference number of the system volume.
  846.     
  847.      Exit:        function result = volume reference number of the volume 
  848.                              containing the currently active system file.
  849. _____________________________________________________________________*/
  850.  
  851.  
  852. short utl_GetSysVol (void)
  853.  
  854. {
  855.     
  856.      short             vRefNum;                  /* vol ref num */
  857.  
  858.      GetVRefNum(*(short*)(SysMap), &vRefNum);
  859.      return vRefNum;
  860. }
  861.  
  862. /*______________________________________________________________________
  863.  
  864.      utl_GetSysWD - Get WDRefNum of Blessed Folder.
  865.     
  866.      Exit:        function result = WDRefNum of Blessed Folder.
  867. _____________________________________________________________________*/
  868.  
  869.  
  870. short utl_GetSysWD (void)
  871.  
  872. {
  873.      if (!GotSysEnviron) GetSysEnvirons();
  874.      return TheWorld.sysVRefNum;
  875. }
  876.  
  877. /*______________________________________________________________________
  878.  
  879.      utl_GetWindGD - Get the GDevice containing a window.
  880.     
  881.      Entry:     theWindow = pointer to window.
  882.     
  883.      Exit:        gd = handle to GDevice, or nil if no color QD.
  884.                         screenRect = bounding rectangle of GDevice, or
  885.                              qd.screenBits.bounds if no color QD.
  886.                         windRect = content rectangle of window, in global
  887.                              coords.
  888.                         hasMB = true if this screen contains the menu bar.
  889.                         
  890.      The routine determines the GDevice (screen) containing the maximum
  891.      intersection with a window.    See TN 79.
  892. _____________________________________________________________________*/
  893.  
  894.  
  895. void utl_GetWindGD (WindowPtr theWindow, GDHandle *gd,
  896.      Rect *screenRect, Rect *windRect, Boolean *hasMB)
  897.     
  898. {
  899.      GrafPtr                savePort;                 /* saved grafport */
  900.      Rect                     sectRect;                 /* intersection rect */
  901.      GDHandle             curDevice;                /* current GDevice */
  902.      GDHandle             dominantDevice;     /* dominant GDevice */
  903.      long                     sectArea;                 /* intersection area */
  904.      long                     maxArea;                    /* max intersection area */
  905.     
  906.      *windRect = theWindow->portRect;
  907.      GetPort(&savePort);
  908.      SetPort(theWindow);
  909.      LocalToGlobal((Point*)&windRect->top);
  910.      LocalToGlobal((Point*)&windRect->bottom);
  911.      if (utl_HaveColor()) {
  912.             windRect->top -= titleBarHeight;
  913.             curDevice = GetDeviceList();
  914.             maxArea = 0;
  915.             dominantDevice = nil;
  916.             while (curDevice) {
  917.                  if (TestDeviceAttribute(curDevice, screenDevice) &&
  918.                         TestDeviceAttribute(curDevice, screenActive)) {
  919.                         SectRect(windRect, &(**curDevice).gdRect, §Rect);
  920.                         sectArea = (long)(sectRect.right - sectRect.left) * 
  921.                              (long)(sectRect.bottom - sectRect.top);
  922.                         if (sectArea > maxArea) {
  923.                              maxArea = sectArea;
  924.                              dominantDevice = curDevice;
  925.                         };
  926.                  };
  927.                  curDevice = GetNextDevice(curDevice);
  928.             };
  929.             windRect->top += titleBarHeight;
  930.             if (dominantDevice) {
  931.                  *gd = dominantDevice;
  932.                  *screenRect = (**dominantDevice).gdRect;
  933.                  *hasMB = dominantDevice == GetMainDevice();
  934.             } else {
  935.                  *gd = nil;
  936.                  *screenRect = qd.screenBits.bounds;
  937.                  *hasMB = true;
  938.             };
  939.      } else {
  940.             *gd = nil;
  941.             *screenRect = qd.screenBits.bounds;
  942.             *hasMB = true;
  943.      };
  944.      SetPort(savePort);
  945. }
  946.  
  947. /*______________________________________________________________________
  948.  
  949.      utl_GetIndGD - Get the nth GDevice.
  950.     
  951.      Entry:     n = device index.
  952.     
  953.      Exit:        gd = handle to GDevice, or nil if no color QD.
  954.                         screenRect = bounding rectangle of GDevice, or
  955.                              qd.screenBits.bounds if no color QD.
  956.                         hasMB = true if this screen contains the menu bar.
  957.  
  958. _____________________________________________________________________*/
  959.  
  960.  
  961. void utl_GetIndGD (short n,GDHandle *gd, Rect *screenRect, Boolean *hasMB)
  962.     
  963. {
  964.      GDHandle             curDevice;                /* current GDevice */
  965.      GDHandle             dominantDevice;     /* dominant GDevice */
  966.     
  967.      if (utl_HaveColor()) {
  968.             dominantDevice = nil;
  969.             curDevice = GetDeviceList();
  970.             while (curDevice && n--) {
  971.                  if (TestDeviceAttribute(curDevice, screenDevice) &&
  972.                         TestDeviceAttribute(curDevice, screenActive))
  973.                              dominantDevice = curDevice;
  974.                  curDevice = GetNextDevice(curDevice);
  975.             }
  976.             if (dominantDevice) {
  977.                  *gd = dominantDevice;
  978.                  *screenRect = (**dominantDevice).gdRect;
  979.                  *hasMB = dominantDevice == GetMainDevice();
  980.             } else {
  981.                  *gd = nil;
  982.                  *screenRect = qd.screenBits.bounds;
  983.                  *hasMB = true;
  984.             };
  985.      } else {
  986.             *gd = nil;
  987.             *screenRect = qd.screenBits.bounds;
  988.             *hasMB = true;
  989.      };
  990. }
  991.  
  992. /*______________________________________________________________________
  993.  
  994.      utl_GetVolFilCnt - Get the number of files on a volume.
  995.     
  996.      Entry:     volRefNum = volume reference number of volume.
  997.     
  998.      Exit:        function result = number of files on volume.
  999.     
  1000.      For serdver volumes this function always returns 0.
  1001. _____________________________________________________________________*/
  1002.  
  1003.  
  1004. long utl_GetVolFilCnt (short volRefNum)
  1005.  
  1006. {
  1007.      HParamBlockRec      pBlock;         /* param block for PHBGetVInfo */
  1008.     
  1009.      pBlock.volumeParam.ioNamePtr = nil;
  1010.      pBlock.volumeParam.ioVRefNum = volRefNum;
  1011.      pBlock.volumeParam.ioVolIndex = 0;
  1012.      (void) PBHGetVInfo(&pBlock, false);
  1013.      return pBlock.volumeParam.ioVFilCnt;
  1014. }
  1015.  
  1016. /*______________________________________________________________________
  1017.  
  1018.      utl_HaveColor - Determine if system has color QuickDraw.
  1019.  
  1020.      Exit:        function result = true if we have color QD.
  1021. _____________________________________________________________________*/
  1022.  
  1023.  
  1024. Boolean utl_HaveColor (void)
  1025.  
  1026. {
  1027.      if (!GotSysEnviron) GetSysEnvirons();
  1028.      return TheWorld.hasColorQD;
  1029. }
  1030.  
  1031. /*______________________________________________________________________
  1032.  
  1033.      utl_HaveSound - Determine if system has the Sound Manager.
  1034.  
  1035.      Exit:        function result = true if we have sound.
  1036. _____________________________________________________________________*/
  1037.  
  1038.  
  1039. Boolean utl_HaveSound (void)
  1040.  
  1041. {
  1042.      if (!GotSysEnviron) GetSysEnvirons();
  1043.      return (TheWorld.systemVersion >= 0x0602);
  1044. }
  1045.  
  1046. /*______________________________________________________________________
  1047.  
  1048.      utl_InitSpinCursor - Initialize animated cursor.
  1049.     
  1050.      Entry:     cursArray = array of handles to cursors.
  1051.                         numCurs = number of cursors to rotate.
  1052.                         tickInterval = interval between cursor rotations.
  1053. _____________________________________________________________________*/
  1054.  
  1055.  
  1056. void utl_InitSpinCursor (CursHandle *cursArray, short numCurs,
  1057.      short tickInterval)
  1058.  
  1059. {
  1060.      CursHandle         h;
  1061.  
  1062.      CursArray = cursArray;
  1063.      CurCurs = 0;
  1064.      NumCurs = numCurs;
  1065.      TickInterval = tickInterval;
  1066.      LastTick = TickCount();
  1067.      h = *cursArray;
  1068.      SetCursor(*h);
  1069. }
  1070.  
  1071. /*______________________________________________________________________
  1072.  
  1073.      utl_InvalGrow - Invalidate Grow Icon.
  1074.     
  1075.      Entry:                 theWindow = pointer to window.
  1076.     
  1077.      This routine should be called before and after calling SizeWindow
  1078.      for windows with grow icons.
  1079. _____________________________________________________________________*/
  1080.  
  1081.  
  1082. void utl_InvalGrow (WindowPtr theWindow)
  1083.  
  1084. {
  1085.      Rect              r;             /* rect to be invalidated */
  1086.     
  1087.      r = theWindow->portRect;
  1088.      r.top = r.bottom - 15;
  1089.      r.left = r.right - 15;
  1090.      InvalRect(&r);
  1091. };
  1092.  
  1093. /*______________________________________________________________________
  1094.  
  1095.      utl_IsDAWindow - Check to see if a window is a DA.
  1096.     
  1097.      Entry:     theWindow = pointer to dialog window.
  1098.                         
  1099.     
  1100.      Exit:        function result = true if DA window.
  1101. _____________________________________________________________________*/
  1102.  
  1103.  
  1104. Boolean utl_IsDAWindow (WindowPtr theWindow)
  1105.  
  1106. {
  1107.      return ((WindowPeek)theWindow)->windowKind < 0;
  1108. }
  1109.  
  1110. /*______________________________________________________________________
  1111.  
  1112.      utl_IsLaser - Check Printer for LaserWriter.
  1113.     
  1114.      Entry:     hPrint = handle to print record.
  1115.     
  1116.      Exit:        function result = true if LaserWriter.
  1117.     
  1118. _____________________________________________________________________*/
  1119.  
  1120.  
  1121. Boolean utl_IsLaser (THPrint hPrint)
  1122.  
  1123. {
  1124.      unsigned char    wDev;                  /* printer device */
  1125.  
  1126.      wDev = (**hPrint).prStl.wDev >> 8;
  1127.      return wDev==3 || wDev==4;
  1128. }
  1129.  
  1130. /*______________________________________________________________________
  1131.  
  1132.      utl_LockControls - Lock Window Controls
  1133.     
  1134.      Entry:     theWindow = pointer to window.
  1135.     
  1136.      This routine moves all the control records in a window high and
  1137.      locks them.    It should be called immediately after creating a new
  1138.      window, and before drawing it.  It works around errors in the Control
  1139.      Manager which showed up when I was testing with TMON's heap scramble and
  1140.      purge option.
  1141. _____________________________________________________________________*/
  1142.  
  1143.  
  1144. void utl_LockControls (WindowPtr theWindow)
  1145.  
  1146. {
  1147.      ControlHandle         theControl;        /* handle to control */
  1148.  
  1149.      theControl = ((WindowPeek)theWindow)->controlList;
  1150.      while (theControl) {
  1151.             MoveHHi((Handle)theControl);
  1152.             HLock((Handle)theControl);
  1153.             theControl = (**theControl).nextControl;
  1154.      };
  1155. }
  1156.  
  1157. /*______________________________________________________________________
  1158.  
  1159.      utl_PlotSmallIcon - Draw a small icon.
  1160.     
  1161.      Entry:     theRect = rectangle in which to draw the small icon.
  1162.                         theHandle = handle to small icon.
  1163.                             
  1164.      For best results, the rectangle should be exactly 16 pixels square.
  1165. _____________________________________________________________________*/
  1166.  
  1167.  
  1168. void utl_PlotSmallIcon (Rect *theRect, Handle theHandle)
  1169.  
  1170. {
  1171.      BitMap          srcBits;             /* Source bitmap for CopyBits */
  1172.     
  1173.      MoveHHi(theHandle);
  1174.      HLock(theHandle);
  1175.      srcBits.baseAddr = *theHandle;
  1176.      srcBits.rowBytes = 2;
  1177.      SetRect(&srcBits.bounds, 0, 0, 16, 16);
  1178.      CopyBits(&srcBits, &qd.thePort->portBits, &srcBits.bounds, theRect,
  1179.             srcCopy, nil);
  1180.      HUnlock(theHandle);
  1181. }
  1182.  
  1183. /*______________________________________________________________________
  1184.  
  1185.      utl_PlugParams - Plug parameters into message.
  1186.     
  1187.      Entry:     line1 = input line.
  1188.                         p0, p1, p2, p3 = parameters.
  1189.                             
  1190.      Exit:        line2 = output line.
  1191.                             
  1192.      This routine works just like the toolbox routine ParamText.
  1193.      The input line may contain place-holders ^0, ^1, ^2, and ^3, 
  1194.      which are replaced by the parameters p0-p3.    The input line
  1195.      must not contain any other ^ characters.  The input and output lines
  1196.      may not be the same string.    Pass nil for parameters which don't
  1197.      occur in line1.    If the output line exceeds 255 characters it's
  1198.      truncated.
  1199. _____________________________________________________________________*/
  1200.  
  1201.  
  1202. void utl_PlugParams (Str255 line1, Str255 line2, Str255 p0, 
  1203.      Str255 p1, Str255 p2, Str255 p3)
  1204.  
  1205. {
  1206.      char                     *in;                /* pointer to cur pos in input line */
  1207.      char                     *out;             /* pointer to cur pos in output line */
  1208.      char                     *inEnd;         /* pointer to end of input line */
  1209.      char                     *outEnd;        /* pointer to end of output line */
  1210.      char                     *param;         /* pointer to param to be plugged */
  1211.      short                    len;                /* length of param */
  1212.     
  1213.      in = line1+1;
  1214.      out = line2+1;
  1215.      inEnd = line1 + 1 + *line1;
  1216.      outEnd = line2 + 256;
  1217.      while (in < inEnd ) {
  1218.             if (*in == '^') {
  1219.                  in++;
  1220.                  if (in >= inEnd) break;
  1221.                  switch (*in++) {
  1222.                         case '0':
  1223.                              param = p0;
  1224.                              break;
  1225.                         case '1':
  1226.                              param = p1;
  1227.                              break;
  1228.                         case '2':
  1229.                              param = p2;
  1230.                              break;
  1231.                         case '3':
  1232.                              param = p3;
  1233.                              break;
  1234.                         default:
  1235.                              continue;
  1236.                  };
  1237.                  if (!param) continue;
  1238.                  len = *param;
  1239.                  if (out + len > outEnd) len = outEnd - out;
  1240.                  memcpy(out, param+1, len);
  1241.                  out += len;
  1242.             } else {
  1243.                  if (out >= outEnd) break;
  1244.                  *out++ = *in++;
  1245.             };
  1246.      };
  1247.      *line2 = out - (line2+1);
  1248. };
  1249.  
  1250. /*______________________________________________________________________
  1251.  
  1252.      utl_RestoreWindowPos - Restore Window Position.
  1253.     
  1254.      Entry:     theWindow = pointer to window.
  1255.                         userState = saved user state rectangle for the window.
  1256.                         zoomed = true if window in zoomed state when saved.
  1257.                         offset = pixel offset used in DragRect calls.
  1258.                         computeStdState = pointer to function to compute standard state.
  1259.                         computeDefState = pointer to function to compute default state.
  1260.     
  1261.      Exit:        window position, size, and zoom state restored.
  1262.                         userState = new user state.
  1263.                         
  1264.      See HIN 6: "When reopening a movable window, check its saved 
  1265.      position.    If the window is in a position to which the user could
  1266.      have dragged it, then leave it there.    If the window can be zoomed
  1267.      and was in the zoomed state when it was last closed, put it in the
  1268.      zoomed state again.    (Note that the current and previous zoomed states
  1269.      are not necessarily the same, since the window may be reopened on a
  1270.      different monitor.)    If the window is not in a position to which the
  1271.      user could have dragged it, then it must be relocated, so use the
  1272.      default location.    However, do not automatically use the default size
  1273.      when using the default location; if the entire window would be visible
  1274.      using the default location and stored size, then use the stored size."
  1275.     
  1276.      The "offset" parameter is usually 4.  When initializing the boundary rectangle
  1277.      for DragWindow calls, normally the boundary rectangle of the desktop gray
  1278.      region is inset by 4 pixels.  If some value other than 4 is used, it should
  1279.      be passed to RestoreWindowPos as the "offset" parameter.
  1280.     
  1281.      The computeStdState function is passed a pointer to the window.    Given
  1282.      the userState in the window zoom info, it must compute the standard
  1283.      (zoom) state in the window zoom info.    This is an application-dependent
  1284.      function.
  1285.     
  1286.      The computeDefState function must determine the default position and
  1287.      size of a new window, and return the result as a rectangle.    This may
  1288.      involve invocation of a staggering algorithm or some other algorithm.
  1289.      This is an application-dependent function.
  1290.     
  1291.      Changed to keep window smaller than the desktop's bounding box.
  1292.      (s-dorner@uiuc.edu, 12/16/91)
  1293. _____________________________________________________________________*/
  1294.  
  1295.  
  1296. void utl_RestoreWindowPos (WindowPtr theWindow, Rect *userState,
  1297.      Boolean zoomed, short offset,
  1298.      utl_ComputeStdStatePtr computeStdState,
  1299.      utl_ComputeDefStatePtr computeDefState)
  1300.  
  1301. {
  1302.      WindowPeek         w;                         /* window pointer */
  1303.      short                    userHeight;      /* height of userState */
  1304.      short                    userWidth;         /* width of userState */
  1305.      Rect                     r;                         /* scratch rectangle */
  1306.      RgnHandle            rgn;                     /* scratch region */
  1307.      Rect                     stdState;          /* standard state */
  1308.      short                    windHeight;      /* window height */
  1309.      short                    windWidth;         /* window width */
  1310.  
  1311.      w = (WindowPeek)theWindow;
  1312.      SanitizeSize(userState);
  1313.      if (!utl_CouldDrag(userState, offset)) {
  1314.             userHeight = userState->bottom - userState->top;
  1315.             userWidth = userState->right - userState->left;
  1316.             (*computeDefState)(theWindow, userState);
  1317.             if (!zoomed) {
  1318.                  r = *userState;
  1319.                  r.bottom = r.top + userHeight;
  1320.                  r.right = r.left + userWidth;
  1321.                  r.top -= titleBarHeight;
  1322.                  InsetRect(&r, -1, -1);
  1323.                  rgn = NewRgn();
  1324.                  RectRgn(rgn, &r);
  1325.                  DiffRgn(rgn, *(RgnHandle*)GrayRgn, rgn);
  1326.                  if (EmptyRgn(rgn)) {
  1327.                         userState->bottom = userState->top + userHeight;
  1328.                         userState->right = userState->left + userWidth;
  1329.                  };
  1330.                  DisposeRgn(rgn);
  1331.             };
  1332.      };
  1333.      MoveWindow(theWindow, userState->left, userState->top, false);
  1334.      windHeight = userState->bottom - userState->top;
  1335.      windWidth = userState->right - userState->left;
  1336.      SizeWindow(theWindow, windWidth, windHeight, true);
  1337.      if (w->dataHandle && w->spareFlag) {
  1338.             (**((WStateData**)w->dataHandle)).userState = *userState;
  1339.             (*computeStdState)(theWindow);
  1340.             if (zoomed) {
  1341.                  stdState = (**((WStateData**)w->dataHandle)).stdState;
  1342.                  MoveWindow(theWindow, stdState.left, stdState.top, false);
  1343.                  windHeight = stdState.bottom - stdState.top;
  1344.                  windWidth = stdState.right - stdState.left;
  1345.                  SizeWindow(theWindow, windWidth, windHeight, true);
  1346.             };
  1347.      };
  1348. }
  1349.  
  1350. /*______________________________________________________________________
  1351.  
  1352.      utl_Rom64 - Check to see if we have the old 64K ROM.
  1353.     
  1354.      Exit:        function result = true if 64K ROM.
  1355. _____________________________________________________________________*/
  1356.  
  1357.  
  1358. Boolean utl_Rom64 (void)
  1359.  
  1360. {
  1361.      return *(short*)ROM85 < 0;
  1362. }
  1363.  
  1364. /*______________________________________________________________________
  1365.  
  1366.      utl_RFSanity - Check a Resource File's Sanity.
  1367.     
  1368.      Entry:     *fName = file name.
  1369.     
  1370.      Exit:        *sane = true if resource fork is sane.
  1371.                         function result = error code.
  1372.                         
  1373.      This routine checks the sanity of a resource file.  The Resource Manager
  1374.      does not do error checking, and can bomb or hang if you use it to open
  1375.      a damaged resource file.  This routine can be called first to precheck
  1376.      the file.
  1377.     
  1378.      The routine checks the entire resource map.
  1379.     
  1380.      It is the caller's responsibility to set the proper default volume and
  1381.      directory.
  1382. _____________________________________________________________________*/
  1383.  
  1384.  
  1385. OSErr utl_RFSanity (Str255 fName, Boolean *sane)
  1386.  
  1387. {
  1388.      ParamBlockRec         fBlock;                /* file param block */
  1389.      short                         refNum;                /* file refnum */
  1390.      long                          count;                 /* number of bytes to read */
  1391.      long                          logEOF;                /* logical EOF */
  1392.      Ptr                             map;                     /* pointer to resource map */
  1393.      unsigned long         dataLWA;             /* offset in file of data end */
  1394.      unsigned long         mapLWA;                /* offset in file of map end */
  1395.      unsigned short      typeFWA;             /* offset from map begin to type list */
  1396.      unsigned short      nameFWA;             /* offset from map begin to name list */
  1397.      unsigned char         *pType;                /* pointer into type list */
  1398.      unsigned char         *pName;                /* pointer to start of name list */
  1399.      unsigned char         *pMapEnd;            /* pointer to end of map */
  1400.      short                         nType;                 /* number of resource types in map */
  1401.      unsigned char         *pTypeEnd;         /* pointer to end of type list */
  1402.      short                         nRes;                    /* number of resources of given type */
  1403.      unsigned short      refFWA;                /* offset from type list to ref list */
  1404.      unsigned char         *pRef;                 /* pointer into reference list */
  1405.      unsigned char         *pRefEnd;            /* pointer to end of reference list */
  1406.      unsigned short      resNameFWA;        /* offset from name list to resource name */
  1407.      unsigned char         *pResName;         /* pointer to resource name */
  1408.      unsigned long         resDataFWA;        /* offset from data begin to resource data */
  1409.      Boolean                     mapOK;                 /* true if map is sane */
  1410.      OSErr                         rCode;                 /* error code */
  1411.     
  1412.      struct {
  1413.             unsigned long         dataFWA;        /* offset in file of data */
  1414.             unsigned long         mapFWA;         /* offset in file of map */
  1415.             unsigned long         dataLen;        /* data area length */
  1416.             unsigned long         mapLen;         /* map area length */
  1417.      } header;
  1418.     
  1419.      /* Open the resource file. */
  1420.     
  1421.      fBlock.ioParam.ioNamePtr = fName;
  1422.      fBlock.ioParam.ioVRefNum = 0;
  1423.      fBlock.ioParam.ioVersNum = 0;
  1424.      fBlock.ioParam.ioPermssn = fsRdPerm;
  1425.      fBlock.ioParam.ioMisc = nil;
  1426.      if (rCode = PBOpenRF(&fBlock, false)) {
  1427.             if (rCode == fnfErr) {
  1428.                  *sane = true;
  1429.                  return noErr;
  1430.             } else {
  1431.                  return rCode;
  1432.             };
  1433.      };
  1434.     
  1435.      /* Get the logical eof of the file. */
  1436.     
  1437.      refNum = fBlock.ioParam.ioRefNum;
  1438.      if (rCode = GetEOF(refNum, &logEOF)) return rCode;
  1439.      if (!logEOF) {
  1440.             *sane = true;
  1441.             if (rCode = FSClose(refNum)) return rCode;
  1442.             return noErr;
  1443.      };
  1444.     
  1445.      /* Read and validate the resource header. */
  1446.     
  1447.      count = 16;
  1448.      if (rCode = FSRead(refNum, &count, (Ptr)&header)) {
  1449.             FSClose(refNum);
  1450.             return rCode;
  1451.      };
  1452.      dataLWA = header.dataFWA + header.dataLen;
  1453.      mapLWA = header.mapFWA + header.mapLen;
  1454.      mapOK = count == 16 && header.mapLen > 28 &&
  1455.             header.dataFWA < 0x01000000 && header.mapFWA < 0x01000000 &&
  1456.             dataLWA <= logEOF && mapLWA <= logEOF &&
  1457.             (dataLWA <= header.mapFWA || mapLWA <= header.dataFWA);
  1458.             
  1459.      /* Read the resource map. */
  1460.     
  1461.      map = nil;
  1462.      if (mapOK) {
  1463.             map = NuPtr(header.mapLen);
  1464.             if (!(rCode = SetFPos(refNum, fsFromStart, header.mapFWA))) {
  1465.                  count = header.mapLen;
  1466.                  rCode = FSRead(refNum, &count, map);
  1467.             };
  1468.      };
  1469.     
  1470.      /* Verify the type list and name list offsets. */
  1471.     
  1472.      if (!rCode) {
  1473.             typeFWA = *(unsigned short*)(map+24);
  1474.             nameFWA = *(unsigned short*)(map+26);
  1475.             mapOK = typeFWA == 28 && nameFWA >= typeFWA && nameFWA <= header.mapLen &&
  1476.                  !(typeFWA & 1) && !(nameFWA & 1);
  1477.      };
  1478.     
  1479.      /* Verify the type list, reference lists, and name list. */
  1480.     
  1481.      if (mapOK) {
  1482.             pType = map + typeFWA;
  1483.             pName = map + nameFWA;
  1484.             pMapEnd = map + header.mapLen;
  1485.             nType = *(short*)pType + 1;
  1486.             pType += 2;
  1487.             pTypeEnd = pType + (nType<<3);
  1488.             if (mapOK = pTypeEnd <= pMapEnd) {
  1489.                  while (pType < pTypeEnd) {
  1490.                         nRes = *(short*)(pType+4) + 1;
  1491.                         refFWA = *(unsigned short*)(pType+6);
  1492.                         pRef = map + typeFWA + refFWA;
  1493.                         pRefEnd = pRef + 12*nRes;
  1494.                         if (!(mapOK = pRef >= pTypeEnd && pRef < pName && 
  1495.                              !(refFWA & 1))) break;
  1496.                         while (pRef < pRefEnd) {
  1497.                              resNameFWA = *(unsigned short*)(pRef+2);
  1498.                              if (resNameFWA != 0xFFFF) {
  1499.                                     pResName = pName + resNameFWA;
  1500.                                     if (!(mapOK = pResName + *pResName < pMapEnd)) break;
  1501.                              };
  1502.                              resDataFWA = *(unsigned long*)(pRef+4) & 0x00FFFFFF;
  1503.                              if (!(mapOK = header.dataFWA + resDataFWA < dataLWA)) break;
  1504.                              pRef += 12;
  1505.                         };
  1506.                         if (!mapOK) break;
  1507.                         pType += 8;
  1508.                  };
  1509.             };
  1510.      };
  1511.     
  1512.      /* Dispose of the resource map, close the file and return. */
  1513.     
  1514.      if (map) DisposPtr(map);
  1515.      if (!rCode) {
  1516.             rCode = FSClose(refNum);
  1517.      } else {
  1518.             (void) FSClose(refNum);
  1519.      };
  1520.      *sane = mapOK;
  1521.      return rCode;
  1522. }
  1523.  
  1524. /*______________________________________________________________________
  1525.  
  1526.      utl_SaveWindowPos - Save Window Position.
  1527.     
  1528.      Entry:     theWindow = window pointer.
  1529.     
  1530.      Exit:        userState = user state rectangle of the window.
  1531.                         zoomed = true if window zoomed.
  1532.                         
  1533.      See HIN 6: "Before closing a movable window, check to see if its
  1534.      location or size have changed.  If so, save the new location and
  1535.      size.    If the window can be zoomed, save the user state and also 
  1536.      save whether or not the window is in the zoomed (standard) sate."
  1537.     
  1538.      We assume in this routine that the caller has already kept track
  1539.      of the fact that this window's location or size has changed, and that
  1540.      we do indeed need to save the location and size.
  1541.     
  1542.      This routine only works if the window's origin has not been offset.
  1543. _____________________________________________________________________*/
  1544.  
  1545.  
  1546. void utl_SaveWindowPos (WindowPtr theWindow, Rect *userState, Boolean *zoomed)
  1547.  
  1548. {
  1549.      GrafPtr         savedPort;         /* saved grafport */
  1550.      WindowPeek  w;                         /* window pointer */
  1551.      Rect              curState;            /* current window rect, global coords */
  1552.      Rect              stdState;            /* standard (zoom) rect, global coords */
  1553.      Point             p;                         /* scratch point */
  1554.      Rect              r;                         /* scratch rect */
  1555.     
  1556.      GetPort(&savedPort);
  1557.      SetPort(theWindow);
  1558.      SetPt(&p, 0, 0);
  1559.      LocalToGlobal(&p);
  1560.      curState = theWindow->portRect;
  1561.      OffsetRect(&curState, p.h, p.v);
  1562.      w = (WindowPeek)theWindow;
  1563.      if (w->dataHandle && w->spareFlag) {
  1564.             /* This window supports zooming */
  1565.             /* Determine if window is zoomed.  The criteria is that both the
  1566.                  top left and bottom right corners of the current window rectangle
  1567.                  and the standard (zoom) rectangle must be within 7 pixels of each
  1568.                  other.  This is the same algorithm as the one used by the standard
  1569.                  system window definition function. */
  1570.             *zoomed = false;
  1571.             stdState = (**((WStateData**)w->dataHandle)).stdState;
  1572.             SetPt(&p, curState.left, curState.top);
  1573.             SetRect(&r, stdState.left, stdState.top, stdState.left, stdState.top);
  1574.             InsetRect(&r, -7, -7);
  1575.             if (PtInRect(p, &r)) {
  1576.                  SetPt(&p, curState.right, curState.bottom);
  1577.                  SetRect(&r, stdState.right, stdState.bottom, stdState.right,
  1578.                         stdState.bottom);
  1579.                  InsetRect(&r, -7, -7);
  1580.                  *zoomed = PtInRect(p, &r);
  1581.             };
  1582.             if (*zoomed) {
  1583.                  *userState = (**((WStateData**)w->dataHandle)).userState;
  1584.             } else {
  1585.                  *userState = curState;
  1586.             };
  1587.      } else {
  1588.             /* This window does not support zooming. */
  1589.             *zoomed = false;
  1590.             *userState = curState;
  1591.      };
  1592.      SetPort(savedPort);
  1593. }
  1594.  
  1595. /*______________________________________________________________________
  1596.  
  1597.      utl_ScaleFontSize - Scale Font Size
  1598.     
  1599.      Entry:     fontNum = font number.
  1600.                         fontSize = nominal font size.
  1601.                         percent = percent change in size.
  1602.                         laser = true if laserwriter.
  1603.     
  1604.      Exit:        function result = scaled font size.
  1605.                         
  1606.      The nominal font size is multiplied by the percentage,
  1607.      then truncated.    For non-laserwriters it is then rounded down
  1608.      to the nearest font size which is available in that true size,
  1609.      without font manager scaling, or which can be generated by doubling
  1610.      an existing font size.
  1611. _____________________________________________________________________*/
  1612.  
  1613.  
  1614. short utl_ScaleFontSize (short fontNum, short fontSize, short percent,
  1615.      Boolean laser)
  1616.     
  1617. {
  1618.      short             nSize;                      /* new size */
  1619.      short             x;                              /* new test size */
  1620.     
  1621.      nSize = fontSize * percent / 100;
  1622.      if (!laser) {
  1623.             x = nSize;
  1624.             while (x > 0) {
  1625.                  if (RealFont(fontNum, x)) break;
  1626.                  if (!(x&1) && RealFont(fontNum, x>>1)) break;
  1627.                  x--;
  1628.             };
  1629.             if (x) nSize = x;
  1630.      };
  1631.      return nSize;
  1632. }
  1633.  
  1634. /*______________________________________________________________________
  1635.  
  1636.      utl_SpinCursor - Animate cursor.
  1637.     
  1638.      After calling InitSpinCursor to initialize an animated cursor, call
  1639.      SpinCursor periodically to make the cursor animate.
  1640. _____________________________________________________________________*/
  1641.  
  1642.  
  1643. void utl_SpinCursor (void)
  1644.  
  1645. {
  1646.      CursHandle         h;                    /* handle to cursor */
  1647.      long                     ticksNow;     /* current tick count */
  1648.     
  1649.      ticksNow = TickCount();
  1650.      if (ticksNow < LastTick + TickInterval) return;
  1651.      LastTick = ticksNow;
  1652.      CurCurs++;
  1653.      if (CurCurs >= NumCurs) CurCurs = 0;
  1654.      h = CursArray[CurCurs];
  1655.      SetCursor(*h);
  1656. }
  1657.  
  1658. /*______________________________________________________________________
  1659.  
  1660.      utl_StaggerWindow - Stagger a New Window
  1661.     
  1662.      Entry:     windRect = window portrect.
  1663.                         initialOffset = intitial pixel offset of window from corner.
  1664.                         offset = offset for subsequent staggered windows.
  1665.     
  1666.      Exit:        pos = window position.
  1667.     
  1668.      According to HIN 6, a new window should be positioned as follows:
  1669.      "The first document window should be positioned in the upper-left corner
  1670.      of the gray area of the main screen (the screen with the menu bar).
  1671.      Each additional independent window should be staggered from the upper-left
  1672.      corner of the screen that contains the largest portion of the
  1673.      frontmost window."  Also, "When a window is used or closed, its original
  1674.      position becomes available again.    The next window opened should use this
  1675.      position.    Similarly, if a window is moved onto a previously available
  1676.      position, that position becomes unavailable again."
  1677.     
  1678.      This routine implements these rules.  A position is considered to be
  1679.      "unavailable" if some other window is within (offset+1)/2 pixels of the
  1680.      position in both the vertical and horizontal directions.
  1681.     
  1682.      If all slots are occupied, the routine attempts to locate the first one
  1683.      which is occupied by only one other window.    If this attempt fails, it
  1684.      tries to locate one which is occupied by only two other windows, etc.
  1685.      Thus, if the screen is filled with staggered windows, subsequent windows
  1686.      will be staggered on top of the existing ones, forming a second "layer."
  1687.      If this layer fills up, a third layer is started, etc.
  1688.     
  1689.      Steve Dorner, UIUC Computing Services Office 9/27/90
  1690.      Invisible windows are no longer considered by the function.
  1691.      Horizontal offset is 2 pixels on small screens
  1692.      Steve Dorner, UIUC Computing Services Office 3/92
  1693.      Leaving 2 pixel margin at screen bottom to allow for autoscroll
  1694.      Added optional insets
  1695.      Steve Dorner, UIUC Computing Services Office 4/92
  1696.      Added parameter for specifying a particular device
  1697. _____________________________________________________________________*/
  1698.  
  1699. #define SIZE_9    540         /* a 9" (or so) screen */               /* sd */
  1700. #define OFF_9     3             /* horizontal offset for 9" screen */   /* sd */
  1701. void utl_StaggerWindow (Rect *windRect, short initialOffset, short offset,
  1702.      Point *pos,short specificDevice)
  1703.  
  1704. {
  1705.      GrafPtr                savedPort;         /* saved grafport */
  1706.      short                    offsetDiv2;      /* offset/2 */
  1707.      short                    windHeight;      /* window height */
  1708.      short                    windWidth;         /* window width */
  1709.      WindowPtr            frontWind;         /* pointer to front window */
  1710.      GDHandle             gd;                      /* GDevice */
  1711.      Rect                     screenRect;      /* screen rectangle */
  1712.      Rect                     junkRect;          /* window rectangle */
  1713.      Boolean                hasMB;                 /* true if screen has menu bar */
  1714.      Point                    initPos;             /* initial staggered window position */
  1715.      Point                    curPos;              /* current staggered window position */
  1716.      WindowPtr            curWind;             /* pointer to current window */
  1717.      Point                    windPos;             /* current window position */
  1718.      short                    deltaH;              /* horizontal distance */
  1719.      short                    deltaV;              /* vertical distance */
  1720.      short                    layer;                 /* layer number */
  1721.      short                    nOccupied;         /* number windows occupying cur pos */
  1722.      Boolean                noPos;                 /* true if no position is on screen */
  1723.      Boolean                is9;                     /* is this a 9" screen? */     /* sd */
  1724.     
  1725.      GetPort(&savedPort);
  1726.      offsetDiv2 = (offset+1)>>1;
  1727.      windHeight = windRect->bottom - windRect->top;
  1728.      windWidth = windRect->right - windRect->left;
  1729.      frontWind = FrontWindow();
  1730.      if (specificDevice) {
  1731.             utl_GetIndGD(specificDevice,&gd,&screenRect,&hasMB);
  1732.      } else if (frontWind) {
  1733.             utl_GetWindGD(frontWind, &gd, &screenRect, &junkRect, &hasMB);
  1734.      } else {
  1735.             screenRect = qd.screenBits.bounds;
  1736.             hasMB = true;
  1737.      };
  1738.      if (hasMB) screenRect.top += utl_GetMBarHeight();
  1739.      screenRect.bottom -= 2;                                                                            /* sd */
  1740.      screenRect.left += GetRLong(DESK_LEFT_STRIP);                                /* sd */
  1741.      screenRect.right -= GetRLong(DESK_RIGHT_STRIP);                            /* sd */
  1742.      screenRect.bottom -= GetRLong(DESK_BOTTOM_STRIP);                        /* sd */
  1743.      screenRect.top += GetRLong(DESK_TOP_STRIP);                                    /* sd */
  1744.      SetPt(&initPos, screenRect.left + initialOffset + 1, 
  1745.             screenRect.top + initialOffset + titleBarHeight);
  1746.      is9 = screenRect.right-screenRect.left<=SIZE_9;                            /* sd */
  1747.      layer = 1;
  1748.      while (true) {
  1749.             /* Test each layer number "layer", starting with 1 and incrementing by 1.
  1750.                  Break out of the loop when we find a position curPos which
  1751.                  is "occupied" by fewer than "layer" other windows. */
  1752.             curPos = initPos;
  1753.             noPos = true;
  1754.             while (true) {
  1755.                  /* Test each possible position curPos.  Break out of the loop
  1756.                         when we have exhaused the possible positions, or when we
  1757.                         have located one which has < layer "occupants". */
  1758.                  curWind = frontWind;
  1759. #ifndef NEWWAY
  1760.                     if (curPos.v + windHeight >= screenRect.bottom ||
  1761.                         curPos.h + windWidth >= screenRect.right) {
  1762.                         break;
  1763.                  };
  1764. #else
  1765.                     if (curPos.h + windWidth >= screenRect.right) break;
  1766.                      if (curPos.v + windHeight >= screenRect.bottom) curPos.v = initPos.v;
  1767. #endif
  1768.                  noPos = false;
  1769.                  nOccupied = 0;
  1770.                  while (curWind) {
  1771.                         /* Scan the window list and count up how many of them "occupy"
  1772.                              the current location curPos.  Break out of the loop when
  1773.                              we reach the end of the list, or when the count is >=
  1774.                              layer. */
  1775.                         if (((WindowPeek)curWind)->visible) {                             /* sd */
  1776.                              SetPt(&windPos, 0, 0);
  1777.                              SetPort(curWind);
  1778.                              LocalToGlobal(&windPos);
  1779.                              deltaH = curPos.h - windPos.h;
  1780.                              deltaV = curPos.v - windPos.v;
  1781.                              if (deltaH < 0) deltaH = -deltaH;
  1782.                              if (deltaV < 0) deltaV = -deltaV;
  1783.                              if (deltaH <= offsetDiv2 && deltaV <= offsetDiv2) {
  1784.                                     nOccupied++;
  1785.                                     if (nOccupied >= layer) break;
  1786.                              };
  1787.                         };                                                                                                    /* sd */
  1788.                         curWind = (WindowPtr)(((WindowPeek)curWind)->nextWindow);
  1789.                  };
  1790.                  if (!curWind) break;
  1791.                  curPos.h += is9 ? OFF_9 : offset;
  1792.                  curPos.v += offset;
  1793.             };
  1794.             if (!curWind || noPos) break;
  1795.             layer++;
  1796.      };
  1797.      SetPort(savedPort);
  1798.    *pos = curPos;
  1799. }
  1800.  
  1801. /*______________________________________________________________________
  1802.  
  1803.      CancelFilter - Command Period Dialog Filter Proc.
  1804.     
  1805.      Entry:     theDialog = pointer to dialog record.
  1806.                         theEvent = pointer to event record.
  1807.     
  1808.      Exit:        if command-period or escape typed:
  1809.     
  1810.                         function result = true.
  1811.                         itemHit = item number of cancel button.
  1812.                         
  1813.                         else if user specified a filterProc on the call to
  1814.                         utl_StopAlert:
  1815.                         
  1816.                         user's filterProc called, function result and itemHit
  1817.                         returned by user's filterProc.
  1818.                         
  1819.                         else:
  1820.                         
  1821.                         function result = false.
  1822.                         itemHit = undefined.
  1823. _____________________________________________________________________*/
  1824.  
  1825.  
  1826. static pascal Boolean CancelFilter (DialogPtr theDialog,
  1827.      EventRecord *theEvent, short *itemHit)
  1828.     
  1829. {
  1830.      short                    key;                /* ascii code of key pressed */
  1831.     
  1832.      if (theEvent->what != keyDown && theEvent->what != autoKey) {
  1833.             if (Filter) {
  1834.                  return (*Filter)(theDialog, theEvent, itemHit);
  1835.             } else {
  1836.                  return false;
  1837.             };
  1838.      } else {
  1839.             key = theEvent->message & charCodeMask;
  1840.             if (key == escapeKey) {
  1841.                  *itemHit = CancelItem;
  1842.                  utl_FlashButton(theDialog, CancelItem);
  1843.                  return true;
  1844.             } else if ((theEvent->modifiers & cmdKey) &&
  1845.                  (key == '.')) {
  1846.                  *itemHit = CancelItem;
  1847.                  utl_FlashButton(theDialog, CancelItem);
  1848.                  return true;
  1849.             } else if (Filter) {
  1850.                  return (*Filter)(theDialog, theEvent, itemHit);
  1851.             } else if (key == returnKey || key==enterKey) {
  1852.                  *itemHit = 1;
  1853.                  utl_FlashButton(theDialog, 1);
  1854.                  return true;
  1855.             } else {
  1856.                  return false;
  1857.             };
  1858.      };
  1859. }
  1860.  
  1861. /*______________________________________________________________________
  1862.  
  1863.      utl_StopAlert - Present Stop Alert
  1864.     
  1865.      Entry:     alertID = resource id of alert.
  1866.                         filterProc = pointer to filter proc.
  1867.                         cancelItem = item number of cancel button, or 0 if
  1868.                              none.
  1869.     
  1870.      Exit:        function result = item number
  1871.                         
  1872.      This routine is identical to the Dialog Manager routine StopAlert,
  1873.      except that it centers the alert on the main window, and if requested,
  1874.      command/period or the Escape key is treated the same as a click on the 
  1875.      Cancel button.
  1876. _____________________________________________________________________*/
  1877.  
  1878.  
  1879. short utl_StopAlert (short alertID, ModalFilterProcPtr filterProc,
  1880.      short cancelItem)
  1881.  
  1882. {
  1883.      Handle                 h;                    /* handle to alert resource */
  1884.      short                    result;         /* function result */
  1885.     
  1886.      h = GetResource('ALRT', alertID);
  1887.      HLock(h);
  1888.      utl_CenterDlogRect(*(Rect**)h, false);
  1889.      if (cancelItem) {
  1890.             Filter = filterProc;
  1891.             CancelItem = cancelItem;
  1892.             result = StopAlert(alertID, CancelFilter);
  1893.      } else {
  1894.             result = StopAlert(alertID, filterProc);
  1895.      };
  1896.      HUnlock(h);
  1897.      return result;
  1898. }
  1899.  
  1900. /*______________________________________________________________________
  1901.  
  1902.      utl_SysHasNotMgr - Check to See if System has Notification Manager.
  1903.     
  1904.      Exit:             function result = true if system has Notification
  1905.                                     Manager..
  1906.     
  1907.      The system version must be >= 6.0.
  1908. _____________________________________________________________________*/
  1909.  
  1910.  
  1911. Boolean utl_SysHasNotMgr (void)
  1912.  
  1913. {
  1914.      if (!GotSysEnviron) GetSysEnvirons();
  1915.      return TheWorld.systemVersion >= 0x0600;
  1916. }
  1917.  
  1918. /*______________________________________________________________________
  1919.  
  1920.      utl_SysHasPopUp - Check to See if System has Popup Menus.
  1921.     
  1922.      Exit:             function result = true if system has popup menus.
  1923.     
  1924.      The system version must be >= 4.1, the machine must have the 128 ROM or
  1925.      later, and the PopUpMenuSelect trap must exist.
  1926. _____________________________________________________________________*/
  1927.  
  1928.  
  1929. Boolean utl_SysHasPopUp (void)
  1930.  
  1931. {
  1932.      if (!GotSysEnviron) GetSysEnvirons();
  1933.      if ((TheWorld.systemVersion < 0x0410) || (TheWorld.machineType == envMac)) {
  1934.             return false;
  1935.      } else {
  1936.             return NGetTrapAddress(_PopUpMenuSelect & 0x3ff, ToolTrap) !=
  1937.                  NGetTrapAddress(_Unimplemented & 0x3ff, ToolTrap);
  1938.      };
  1939. }
  1940.  
  1941. /*______________________________________________________________________
  1942.  
  1943.      utl_VolIsMFS - Test for MFS volume.
  1944.     
  1945.      Entry:     vRefNum = volume reference number.
  1946.     
  1947.      Exit:        function result = true if volume is MFS.
  1948. _____________________________________________________________________*/
  1949.  
  1950.  
  1951. Boolean utl_VolIsMFS (short vRefNum)
  1952.  
  1953. {
  1954.      HParamBlockRec      vBlock;                /* vol info param block */
  1955.     
  1956.      vBlock.volumeParam.ioNamePtr = nil;
  1957.      vBlock.volumeParam.ioVolIndex = 0;
  1958.      vBlock.volumeParam.ioVRefNum = vRefNum;
  1959.      vBlock.volumeParam.ioVSigWord = 0xd2d7;        /* in case we don't have HFS */
  1960.      (void) PBHGetVInfo(&vBlock, false);
  1961.      return vBlock.volumeParam.ioVSigWord == 0xd2d7;
  1962. }
  1963.  
  1964. /*______________________________________________________________________
  1965.  
  1966.      utl_WaitNextEvent - Get Next Event.
  1967.     
  1968.      Entry:     eventMask = event mask.
  1969.                         sleep = sleep interval.
  1970.                         mouseRgn = mouse region.
  1971.     
  1972.      Exit:        theEvent = the next event.
  1973.                         function result = true if event to be processed.
  1974.                         
  1975.      This routine calls WaitNextEvent if the trap exists, otherwise it
  1976.      calls GetNextEvent.    
  1977.     
  1978.      If GetNextEvent is called, the sleep and mouseRgn parameters are 
  1979.      ignored.  SystemTask is also called.
  1980.                         
  1981.      This routine also saves and restores the current grafport.  This is
  1982.      necessary to protect against some GetNextEvent trap patches which change
  1983.      the grafport without restoring it (e.g., the Flex screen saver).
  1984. _____________________________________________________________________*/
  1985.  
  1986.  
  1987. Boolean utl_WaitNextEvent (short eventMask, EventRecord *theEvent,
  1988.      long sleep, RgnHandle mouseRgn)
  1989.  
  1990. {
  1991.      GrafPtr                curPort;        /* pointer to current grafport */
  1992.      Boolean                result;         /* function result */
  1993.      static short     wne = 2;        /* 0 if WaitNextEvent does not exist
  1994.                                                                  1 if WaitNextEvent exists
  1995.                                                                  2 if we don't yet know (first call) */
  1996.     
  1997.      /* Find out whether the WaitNextEvent trap is implemented if this is 
  1998.             the first call. */
  1999.     
  2000.      if (wne == 2) {
  2001.             if (!GotSysEnviron) GetSysEnvirons();
  2002.             if (TheWorld.machineType < 0) {
  2003.                  wne = false;
  2004.             } else {
  2005.                  wne = (NGetTrapAddress(_WaitNextEvent & 0x3ff, ToolTrap) ==
  2006.                         NGetTrapAddress(_Unimplemented & 0x3ff, ToolTrap)) ? 0 : 1;
  2007.             };
  2008.      };
  2009.     
  2010.      /* Save the port, call the trap, and restore the port. */
  2011.     
  2012.      GetPort(&curPort);
  2013.      if (wne) {
  2014.             result = WaitNextEvent(eventMask, theEvent, sleep, mouseRgn);
  2015.      } else {
  2016.             SystemTask();
  2017.             result = GetNextEvent(eventMask, theEvent);
  2018.      };
  2019.      SetPort(curPort);
  2020.      return result;
  2021. }
  2022.  
  2023.